/**
 * 百家乐游戏工具函数库
 */

/**
 * 翻译游戏结果文本
 * @param {string} result - 游戏结果 ('player', 'banker', 'tie')
 * @returns {string} 翻译后的文本
 */
export function translateResult(result) {
  switch(result) {
    case 'player': return '闲';
    case 'banker': return '庄';
    case 'tie': return '和';
    default: return result;
  }
}

/**
 * 计算总输赢
 * @param {Array} history - 游戏历史记录
 * @returns {number} 总输赢金额
 */
export function calculateTotalWinLoss(history) {
  // 遍历所有历史记录，累加每一局的输赢
  return history.reduce((total, record) => {
    let roundWinLoss = 0;
    
    if (record.win_or_lose === 1) {
      // 赢了：赔付金额减去下注金额
      roundWinLoss = record.payout - record.bet_amount;
    } else if (record.win_or_lose === 0) {
      // 输了：负的下注金额
      roundWinLoss = -record.bet_amount;
    } else if (record.win_or_lose === 2) {
      // 和局时闲庄下注：不输不赢，为0
      roundWinLoss = 0;
    }
    
    // 累加到总输赢中
    return total + roundWinLoss;
  }, 0);
}

/**
 * 检查一张牌是否为红色(红桃或方块)
 * @param {string} card - 牌面字符串
 * @returns {boolean} 是否为红色牌
 */
export function isRedCard(card) {
  if (!card) return false;
  return card.includes('♥') || card.includes('♦');
}

/**
 * 获取历史记录中庄、闲、和的统计数据
 * @param {Array} resultsHistory - 结果历史记录
 * @returns {Object} 统计数据对象
 */
export function getResultsStats(resultsHistory) {
  const playerCount = resultsHistory.filter(result => result === 'player').length;
  const bankerCount = resultsHistory.filter(result => result === 'banker').length;
  const tieCount = resultsHistory.filter(result => result === 'tie').length;
  const totalGames = resultsHistory.length;
  
  return {
    playerCount,
    bankerCount,
    tieCount,
    totalGames,
    playerPercentage: totalGames > 0 ? (playerCount / totalGames) * 100 : 0,
    bankerPercentage: totalGames > 0 ? (bankerCount / totalGames) * 100 : 0,
    tiePercentage: totalGames > 0 ? (tieCount / totalGames) * 100 : 0
  };
}

/**
 * 计算百家乐点数
 * @param {Array} cards - 牌面数组
 * @returns {number} 计算后的点数
 */
export function calculatePoints(cards) {
  if (!cards || cards.length === 0) return 0;
  
  let total = 0;
  for (const card of cards) {
    const value = getCardValue(card);
    total += value;
  }
  
  return total % 10;
}

/**
 * 获取单张牌的点数
 * @param {string} card - 牌面字符串
 * @returns {number} 牌的点数
 */
function getCardValue(card) {
  if (!card) return 0;
  
  const rank = card.slice(1); // 去掉花色，获取牌面
  
  if (rank === 'A') return 1;
  if (['10', 'J', 'Q', 'K'].includes(rank)) return 0;
  return parseInt(rank, 10);
}

/**
 * 计算百家乐赔率
 * @param {string} betChoice - 下注选择 ('player', 'banker', 'tie')
 * @param {string} result - 游戏结果 ('player', 'banker', 'tie')
 * @param {number} betAmount - 下注金额
 * @param {number} bankerPoints - 庄家点数 (用于计算免佣规则)
 * @returns {Object} 包含赔付金额和输赢状态的对象
 */
export function calculatePayout(betChoice, result, betAmount, bankerPoints) {
  const isWin = betChoice === result;
  let payout = 0;
  
  if (isWin) {
    if (betChoice === 'banker') {
      if (bankerPoints === 6) {
        payout = betAmount * 0.5 + betAmount; // 庄6点赢，赔率为1:0.5
      } else {
        payout = betAmount * 2; // 庄其他点数赔率为1:1
      }
    } else if (betChoice === 'player') {
      payout = betAmount * 2; // 闲赔率为1:1
    } else { // tie
      payout = betAmount * 9; // 和赔率为1:8
    }
  }
  
  const winLoss = isWin ? payout - betAmount : -betAmount;
  
  return {
    payout,
    isWin,
    winLoss
  };
}

/**
 * 格式化路单数据，实现百家乐常见的路单显示规则
 * 相同结果向下排列，不同结果另起新列
 * 注意："和"结果总是沿着同一列向下排列，不论前一个结果是什么
 * @param {Array} resultsHistory - 游戏结果历史数组
 * @returns {Array} 返回二维数组，表示格式化后的路单
 */
export function formatRoadmap(resultsHistory) {
  if (!resultsHistory || resultsHistory.length === 0) {
    return [];
  }
  
  // 首先获取时间顺序的结果（复制一份并反转，因为resultsHistory是最新的在前面）
  const orderedResults = [...resultsHistory].reverse();
  
  // 创建二维数组存储路单
  const roadmap = [];
  
  // 处理第一个结果
  roadmap.push([orderedResults[0]]);
  
  // 从第二个结果开始处理
  for (let i = 1; i < orderedResults.length; i++) {
    const currentResult = orderedResults[i];
    const lastColIndex = roadmap.length - 1;
    const lastCol = roadmap[lastColIndex];
    
    // 查找上一个非"和"的结果，用于决定是否另起新列
    let lastNonTieResult = null;
    for (let j = lastCol.length - 1; j >= 0; j--) {
      if (lastCol[j] !== 'tie') {
        lastNonTieResult = lastCol[j];
        break;
      }
    }
    
    // 如果没有找到非"和"的结果，说明整列都是"和"，使用该列第一个结果
    if (lastNonTieResult === null) {
      lastNonTieResult = lastCol[0];
    }
    
    // 如果当前结果是"和"，总是添加到当前列
    if (currentResult === 'tie') {
      lastCol.push(currentResult);
    } 
    // 如果当前结果与上一个非"和"结果相同，则添加到当前列
    else if (currentResult === lastNonTieResult) {
      lastCol.push(currentResult);
    } 
    // 结果不同且不是"和"，创建新列
    else {
      roadmap.push([currentResult]);
    }
  }
  
  return roadmap;
} 